component{
	// Configure ColdBox Application
	function configure(){
		/*
		cacheBox = {
			configFile 			= "",
			logBoxConfig 		= "",
			scopeRegistration 	= {
				enabled	= true,
				scope	= "application",
				key		= "cacheBox"
			},
			defaultCache		= {
				ObjectDefaultTimeout			= 60, 				//The default lifespan of an object in minutes
				ObjectDefaultLastAccessTimeout	= 30,				//The default last access or idle timeout in minutes 
				UseLastAccessTimeouts			= true,				//Use or not idle timeouts
				ReapFrequency					= 2,				//The delay in minutes to produce a cache reap (Not guaranteed) 
				FreeMemoryPercentageThreshold	= 0,				//The numerical percentage threshold of free JVM memory to have available before caching. If the jvm free memory falls below this setting, the cache will run the eviction policies in order to cache new objects. (0=Unlimited) 
				MaxObjects						= 200,				//The maximum number of objects for the cache
				EvictionPolicy					= "LRU",			//The eviction policy algorithm class to use. ColdBox ships with :LFU (Least Frequently Used), LRU (Least Recently Used), FIFO (First In First Out)
				EvictCount						= 1,				//The number of objects to evict once an execution of the policy is requested. You can increase this to make your evictions more aggressive
				ObjectStore						= "ConcurrentStore",//The object store to use for caching objects. ColdBox ships with the following object stores: ConcurrentStore - Uses concurrent hashmaps for increased performance, ConcurrentSoftReferenceStore - Concurrent hashmaps plus java soft references for JVM memory sensitiviy, DiskStore - Uses a physical disk location for caching (Uses java serialization for complex objects), JDBCStore - Uses a JDBC datasource for caching (Uses java serialization for complex objects)
				ColdboxEnabled					= true				//A flag that switches on/off the usage of either a plain vanilla CacheBox provider an a ColdBox enhanced provider. This must be true when used within a ColdBox application and it applies for the default cache ONLY
			},
			caches				= {
				sampleCache1 = {
					provider="coldbox.system.cache.providers.CacheBoxProvider",
					properties = {
						objectDefaultTimeout="20",
						useLastAccessTimeouts="false",
						reapFrequency="1",
						evictionPolicy="LFU",
						evictCount="1",
						maxObjects="100",
						objectStore="ConcurrentSoftReferenceStore"
					}
				},
				sampleCache2 = {
					provider = "coldbox.system.cache.providers.CFProvider"
				}
			}		
		};
		*/
		
		coldbox = {
			
			// Application setup
			AppName 				= "coldfusionfrance",//The name of your application
			EventName 				= "event",		//Default event name variable to use in URL/FORM etc.
			
			// Development Settings
			DebugMode				= false,	//Default Debugmode boolean flag (Set to false in production environments)
			DebugPassword			= "",	//The Debug Password to use in order to activate/deactivate debugmode,activated by url actions
			ReinitPassword			= "",	//The fwreinit password to use in order to reinitialize the framework and application.Optional, else leave blank
			HandlersIndexAutoReload = false,	//Flag to Auto reload the internal handlers directory listing. False for production
			ConfigAutoReload		= false, //Flag to auto reload the config.xml settings. False for production
			
			//Implicit Event Settings
			DefaultEvent			= "General.index",		//Default Event to run if no event is set or passed. Usually the event to be fired first (NOTE: use event handler syntax)
			RequestStartHandler		= "Main.onRequestStart",	//Event Handler to run on the start of a request, leave blank if not used. Emulates the Application.cfc onRequestStart method
			RequestEndHandler		= "Main.onRequestEnd",		//Event Handler to run at end of all requests, leave blank if not used. Emulates the Application.cfc onRequestEnd method
			ApplicationStartHandler = "Main.onAppInit",			//Event Handler to run at the start of an application, leave blank if not used. Emulates the Application.cfc onApplicationStart method
			ApplicationEndHandler	= "Main.onAppEnd",			//Event Handler to run at the end of an application, leave blank if not used. Emulates the Application.cfc onApplicationEnd method
			SessionStartHandler 	= "Main.onSessionStart",	//Event Handler to run at the start of a session, leave blank if not used.
			SessionEndHandler		= "Main.onSessionEnd",		//Event Handler to run at the end of a session, leave blank if not used
			missingTemplateHandler	= "Main.onMissingTemplate",	//Executes whenever a CFML template is requested and not found in the application via onMissingTemplate()
			
			//Extension Points Settings
			UDFLibraryFile			= "",	//UDF Library To Load on every request for your views and handlers
			ColdboxExtensionsLocation = "",	//The dot notation path of where the framework extensions root is located.
			ModulesExternalLocation	= [],	//An array of locations of where ColdBox should look for modules to load into your application. The path can be a cf mapping or cfinclude  compatible location. Modules are searched and loaded in the order of the declared locations. The first location ColdBox will search for modules is the conventions folder modules
			PluginsExternalLocation	= "",	//The dot notation path of where to look for custom plugins for your application. This path is a secondary location, meaning that the conventions folder takes precedence
			ViewsExternalLocation	= "",	//The CF include path of where to look for secondary views for your application. Secondary views look just like normal views except the framework looks in the conventions folder first and if not found then searches this location. 
			LayoutsExternalLocation	= "",	//The CF include path of where to look for secondary layouts for your application. Secondary layouts look just like normal layouts except the framework looks in the conventions folder first and if not found then searches this location.
			HandlersExternalLocation= "",	//Declare the external handlers base invocation path, if used. You have to use dot notation.Example: mymapping.myhandlers
			RequestContextDecorator	= "",	//Request Context Decorator, leave blank if not using. Full instantiation path
			
			//Exception Handling
			ExceptionHandler		= "Main.onException",	//The event handler to execute on all framework exceptions. Event Handler syntax required
			OnInvalidEvent			= "Main.onInvalidEvent",	//What event to fire when an invalid event is detected
			CustomErrorTemplate		= "",	//Full path from the application's root to your custom error page, else leave blank.
			
			//Application Aspects
			HandlerCaching			= true,	//Flag to cache handlers. Default if left blank is true.
			EventCaching			= true,	//Flag to cache events if metadata declared. Default is true			
			ProxyReturnCollection	= false,	//Flag if the proxy returns the entire request collection or what the event handlers return, default is false
			FlashURLPersistScope	= "session"	//The type of flash RAM persistence to use in your application. The allowed shorthand notations are the following: session, client, cluster, cache, mock
		};
		
		conventions = {
			handlersLocation= "handlers",	//This element is to declare where your handlers are stored within the application root.
			pluginsLocation	= "plugins",	//This element is to declare where your custom plugins are stored within the application root.
			viewsLocation	= "views",		//This element is to declare where your views are stored within the application root.
			layoutsLocation	= "layouts",	//This element is to declare where your layouts are stored within the application root.
			modelsLocation	= "model",		//This element is to declare where your model objects are stored within the application root
			modulesLocation	= "modules",	//This element is to declare where your modules are stored within the application root.
			eventAction		= "index"		//This element defines what is the default event action an event handler will use if an incoming event has no defined action. If there is no action then the framework will look for this action in the handler and execute it. 
		};
		
		models = {
			 objectCaching 		= true
			,definitionFile 	= "config/ModelMappings.cfm"
			,externalLocation 	= "model"
			,SetterInjection 	= false
			,DICompleteUDF 		= "onDIComplete"
			,StopRecursion 		= ""
		};

		datasources = {
			coldfusi = {
				name	="coldfusi_base",
				dbType	="mysql",
				username="root",
				password=""
			}
		};
		
		debugger = {
			EnableDumpVar					= true,	//This feature is enabled by default to permit the url dumpvar parameter
			persistentRequestProfilers 		= true,	//Enables the tracking of request profilers in your application when in debug mode
			maxPersistentRequestProfilers	= 10,	//The maximum number of profilers to keep in memory when profiling. This is a stack of profilers that renews itself on each request.
			maxRCPanelQueryRows				= 50,	//The maximum number of rows to dump in the request collection panel 
			showTracerPanel					= true,	//Whether the tracer panel is enabled in the debugger rendering 
			expandedTracerPanel				= true,	//Whether the tracer panel will be expanded by default or collapsed 
			showInfoPanel					= true, //Whether the info panel is enabled in the debugger rendering 
			expandedInfoPanel				= false, //Whether the info panel will be expanded by default or collapsed 
			showCachePanel					= true, //Whether the cache panel is enabled in the debugger rendering 
			expandedCachePanel				= false, //Whether the cache panel will be expanded by default or collapsed 
			showRCPanel						= true, //Whether the request collection panel is enabled in the debugger rendering 
			expandedRCPanel					= true, //Whether the request collection panel will be expanded by default or collapsed 
			showModulesPanel				= true, //Whether the modules panel is enabled in the debugger rendering 
			expandedModulesPanel			= false 	//Whether the modules panel will be expanded by default or collapsed 
		};
		
		environments = {
			development = "^127.0.0.1"
		};
	
		//i18n & Localization
		i18n = {
			//defaultResourceBundle = "includes/i18n/main",	//The base path of where resource bundles will be stored and the initial name of the default resource bundle to load
			//defaultLocale = "fr_FR",						//The default locale to give users when hitting your application. Please remember that this is using standard java locale syntax. Some examples are es_SV, es_DO. This value gets appended to the default resource bundle setting to define the default language property file to load: includes/main_en_US.properties
			//localeStorage = "session",						//This is where the framework will store the client's locale in order to track them and you have three possibilities (session,client,cookie)
			//unknownTranslation = "**NOT FOUND**"			//A setting used by the resource bundle plugin whenever a translation cannot be found. Instead of returning the default bogus _UNKNOWN_, you can choose your own string to return
		};
		
		//Interceptor Settings
		interceptorSettings = {
			throwOnInvalidStates = true	//This tells the interceptor service to throw an exception if the state announced for interception is not valid or does not exist. 
			//customInterceptors = ""		//This key is a comma delimited list of custom interception points you will be registering for execution. This is the way to provide an observer-observable pattern to your applications. Again, please see the [Interceptors | Interceptor's Guide] for more information. Just note that here is where you register the custom interception points separated by a comma if more than one. This is needed so when interceptors are registered for execution points, these points will also be searched and registered for
		};
		
		/*
		//LogBox DSL
		logBox = {
			// Define Appenders
			appenders = {
				coldboxTracer = { class="coldbox.system.logging.appenders.ColdboxTracerAppender" }
			},
			// Root Logger
			root = { levelmax="DEBUG", appenders="*" },
			// Implicit Level Categories
			debug = [ "coldbox.system" ] 
		};
		* */
		
		//Register interceptors as an array, we need order
		interceptors = [
			{ //Autowire
				class="coldbox.system.interceptors.Autowire",
				properties={
					useSetterInjection = false
				}
			},{ //SES
				class="coldbox.system.interceptors.SES",
				properties={
					configFile = "config/Routes.cfm"
				}
			}
		];
		
		//Layout Settings
		layoutSettings = {
			defaultLayout = "Layout.Main.cfm",
			defaultView   = ""
		};
		/*
		//WireBox Integration
		wireBox = { 
			enabled = true,
			//binder="config.WireBox", 
			singletonReload=true 
		};
		* /
		
		//Interceptor Settings
		interceptorSettings = {
			throwOnInvalidStates = false,
			customInterceptionPoints = ""
		};
				
		/*
		layouts = [	
			{ 
				name	="",				//The name or alias of the layout you are about to register or associate.
				file	="",	//The name of the file that represents this layout name. This file needs to exist in either the conventions layouts folder or the layouts external location
				views	="",		//The name of the file that will be rendered whenever a handler does not set a view for rendering. This file needs to exist in either the conventions views folder or the views external location. Do not append a .cfm extension, just the full name of the view
				folders	=""		//A list of regular expression folder names that you want to associate with the layout. This means that if you are rendering a view and that view exists in a folder 
			}
		];
		*/

/*
		//LogBox DSL
		logBox = {
			// Define Appenders
			appenders = {
				coldboxTracer = { 
					class="coldbox.system.logging.appenders.ColdboxTracerAppender",
					layout="coldbox.testing.cases.logging.MockLayout", 
					properties = {
						name = "awesome"
					},
					rollingFile = {
						class="coldbox.system.logging.appenders.AsyncRollingFileAppender",
						levelMax="DEBUG",
						levelMin="FATAL",
						properties={
							filePath="/#appMapping#/logs",
							autoExpand="true",
							fileMaxSize="3000",
							fileMaxArchives="5"
						}
					}
				}

			},
			// Root Logger
			root = {
				levelmax="DEBUG",
				appenders="*"
			},
			// Implicit Level Categories
			info = [ "coldbox.system" ]
		};
*/	
		mailSettings = {
//			server = "mail.mydomain.com",
//			username = "lui@mydomain.com",
//			password = "YouRock",
//			port = 25
		};
	
		modules = {};
		
		// custom settings
		settings = {
			IndexFile = ""
		};
		
		webservices = {};	
	}
	
	function development(){
		//Application Aspects
		coldbox.HandlerCaching			= false;	//Flag to cache handlers. Default if left blank is true.
		coldbox.EventCaching			= false;	//Flag to cache events if metadata declared. Default is true			
		coldbox.ProxyReturnCollection	= false;	//Flag if the proxy returns the entire request collection or what the event handlers return, default is false
		coldbox.FlashURLPersistScope	= "session";	//The type of flash RAM persistence to use in your application. The allowed shorthand notations are the following: session, client, cluster, cache, mock
		
		// Development Settings
		coldbox.DebugMode				= true;	//Default Debugmode boolean flag (Set to false in production environments)
		coldbox.DebugPassword			= "";	//The Debug Password to use in order to activate/deactivate debugmode,activated by url actions
		coldbox.ReinitPassword			= "";	//The fwreinit password to use in order to reinitialize the framework and application.Optional, else leave blank
		coldbox.HandlersIndexAutoReload = true;	//Flag to Auto reload the internal handlers directory listing. False for production
		coldbox.ConfigAutoReload		= false; //Flag to auto reload the config.xml settings. False for production
		
		//Set /index.cfm as mandatory
		settings.IndexFile = "/index.cfm";
		// Add dev only interceptors
		//arrayAppend(interceptors, {class="coldbox.system.interceptors.ColdboxSidebar} );
	}
	
}